""" _*_ coding : utf-8 _*_
 @Time: 2025/8/20 14:21
 @Author : 虎
 @File : urls
 @Project : education
"""

from apps.schemas.login import LoginRequest
from fastapi import APIRouter, HTTPException
from apps.models import Login
from fastapi import APIRouter, HTTPException, Depends
from passlib.context import CryptContext
from .config import JWTUtils, JWTConfig  # 导入修改后的工具类

users = APIRouter()
# 创建密码上下文
pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")


def verify_password(plain_password: str, hashed_password: str) -> bool:
    """验证密码，处理可能的明文密码"""
    try:
        # 先尝试验证哈希密码
        return pwd_context.verify(plain_password, hashed_password)
    except Exception:
        # 如果验证失败，可能是明文密码，直接比较
        return plain_password == hashed_password


def hash_password(password: str) -> str:
    """加密密码"""
    return pwd_context.hash(password)


@users.post("/login")
async def login(login_data: LoginRequest):
    """
    登录接口 - 兼容明文和加密密码，返回JWT token
    """
    try:
        # 查找用户
        user = await Login.filter(username=login_data.username).first()
        print("user是：", user.username)

        if not user:
            return {
                "code": 401,
                "message": "用户名或密码错误",
                "data": None
            }

        # 验证密码（兼容明文和加密）
        if not verify_password(login_data.password, user.password):
            return {
                "code": 401,
                "message": "用户名或密码错误",
                "data": None
            }

        # 如果密码是明文的，自动升级为加密
        if not pwd_context.identify(user.password):
            user.password = hash_password(login_data.password)
            await user.save()

        # 验证角色 - 这里可能是问题所在！
        # 如果前端传的role和数据库不一致，就会返回403
        # 建议改为：如果用户有多个角色，或者前端不传role时如何处理
        if login_data.role and user.role != login_data.role:
            return {
                "code": 403,
                "message": "角色不匹配",
                "data": None
            }

        # 使用JWT工具类生成token
        token_data = {
            "sub": user.username,
            "role": user.role,  # 使用数据库中的角色
            "user_id": str(user.id),
            "username": user.username
        }

        # 生成访问令牌
        access_token = JWTUtils.create_access_token(data=token_data)

        return {
            "code": 200,
            "message": "登录成功",
            "data": {
                "token": access_token,
                #token_type代表授权类型，这里使用bearer
                "token_type": "bearer",
                #expires_in代表token的过期时间，这里是JWTConfig中定义的ACCESS_TOKEN_EXPIRE_MINUTES，单位是分钟，转换为秒
                "expires_in": JWTConfig.ACCESS_TOKEN_EXPIRE_MINUTES * 60,
                "user_info": {
                    "user_id": str(user.id),
                    "username": user.username,
                    "role": user.role
                }
            }
        }

    except Exception as e:
        print(f"登录错误: {e}")
        return {
            "code": 500,
            "message": "服务器内部错误",
            "data": None
        }


# 注册
@users.post("/register")
async def register(register_data: LoginRequest):
    """
    注册
    :param register_data: 登录数据
    :return: 注册结果
    """
    # 检查用户名是否已存在
    existing_user = await Login.filter(username=register_data.username).first()
    if existing_user:
        raise HTTPException(status_code=400, detail="用户名已存在")
    # 加密密码
    hashed_password = pwd_context.hash(register_data.password)

    # 创建用户数据字典，替换明文密码为加密后的密码
    user_data = register_data.dict()
    user_data["password"] = hashed_password

    # 创建新用户
    user = await Login.create(**user_data)

    return {
        "code": 200,
        "message": "注册成功",
        "data": {
            "username": user.username,
            "role": register_data.role
        }
    }
